Machine-Learning-Pipeline: Entwicklung benutzerdefinierter Transformatoren in Scikit-learn

Machine-Learning-Pipelines sind unerlässlich für die Erstellung robuster und wartbarer Modelle für maschinelles Lernen. Scikit-learn (sklearn) bietet ein leistungsstarkes Framework zur Erstellung dieser Pipelines. Eine Schlüsselkomponente jeder guten Pipeline ist die Fähigkeit, benutzerdefinierte Datentransformationen durchzuführen. Dieser Artikel befasst sich mit der Entwicklung benutzerdefinierter Transformatoren in Scikit-learn und bietet eine umfassende Anleitung für Datenwissenschaftler und Machine-Learning-Ingenieure weltweit.

Was ist eine Machine-Learning-Pipeline?

Eine Machine-Learning-Pipeline ist eine Abfolge von Datenverarbeitungskomponenten, die miteinander verkettet sind. Diese Komponenten umfassen typischerweise:

• Datenbereinigung: Umgang mit fehlenden Werten, Ausreißern und Inkonsistenzen.
• Feature Engineering: Erstellen neuer Merkmale aus vorhandenen, um die Modellleistung zu verbessern.
• Merkmalsauswahl: Auswahl der relevantesten Merkmale für das Modell.
• Modelltraining: Trainieren eines Machine-Learning-Modells mit den vorbereiteten Daten.
• Modellbewertung: Beurteilung der Leistung des trainierten Modells.

Die Verwendung einer Pipeline bietet mehrere Vorteile, darunter:

• Reproduzierbarkeit: Sicherstellen, dass dieselben Datenverarbeitungsschritte konsistent angewendet werden.
• Modularität: Aufteilen des Datenverarbeitungs-Workflows in wiederverwendbare Komponenten.
• Wartbarkeit: Erleichterung der Aktualisierung und Wartung des Datenverarbeitungs-Workflows.
• Vereinfachte Bereitstellung: Straffung des Prozesses zur Bereitstellung von Machine-Learning-Modellen.

Warum benutzerdefinierte Transformatoren?

Scikit-learn bietet eine breite Palette integrierter Transformatoren für gängige Datenverarbeitungsaufgaben. In vielen realen Szenarien müssen Sie jedoch benutzerdefinierte Datentransformationen durchführen, die spezifisch für Ihre Daten und Ihr Problem sind. Hier kommen benutzerdefinierte Transformatoren ins Spiel. Sie ermöglichen es Ihnen, Ihre benutzerdefinierte Datenverarbeitungslogik in wiederverwendbaren Komponenten zu kapseln, die nahtlos in eine Scikit-learn-Pipeline integriert werden können.

Stellen Sie sich zum Beispiel vor, Sie arbeiten mit Kundendaten einer globalen E-Commerce-Plattform. Möglicherweise müssen Sie einen benutzerdefinierten Transformator erstellen, der Transaktionswährungen auf der Grundlage historischer Wechselkurse in eine gemeinsame Währung (z. B. USD) umrechnet. Oder betrachten Sie ein Szenario mit Sensordaten von IoT-Geräten in verschiedenen Ländern; Sie könnten einen benutzerdefinierten Transformator erstellen, um Daten basierend auf lokalen Zeitzonen und Maßeinheiten zu normalisieren.

Erstellen eines benutzerdefinierten Transformators

Um einen benutzerdefinierten Transformator in Scikit-learn zu erstellen, müssen Sie eine Klasse erstellen, die von sklearn.base.BaseEstimator und sklearn.base.TransformerMixin erbt. Ihre Klasse muss zwei Methoden implementieren:

• fit(self, X, y=None): Diese Methode lernt alle Parameter, die für die Transformation benötigt werden. In vielen Fällen gibt diese Methode einfach self zurück.
• transform(self, X): Diese Methode wendet die Transformation auf die Daten an.

Hier ist ein grundlegendes Beispiel für einen benutzerdefinierten Transformator, der jedem Merkmal einen konstanten Wert hinzufügt:

            from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class AddConstantTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, constant=1):
        self.constant = constant

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        return X + self.constant

            

              
                Copy
              
            
          

Lassen Sie uns dieses Beispiel aufschlüsseln:

• Notwendige Bibliotheken importieren: BaseEstimator, TransformerMixin aus sklearn.base und numpy für numerische Operationen.
• Klasse definieren: AddConstantTransformer erbt von BaseEstimator und TransformerMixin.
• Konstruktor (__init__): Diese Methode initialisiert den Transformator mit einem constant-Wert (Standard ist 1).
• fit-Methode: Diese Methode gibt einfach self zurück, da dieser Transformator keine Parameter aus den Daten lernen muss.
• transform-Methode: Diese Methode fügt den constant-Wert zu jedem Element in den Eingabedaten X hinzu.

Anwendungsbeispiel

            from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

X = np.array([[1, 2], [3, 4], [5, 6]])

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('add_constant', AddConstantTransformer(constant=2))
])

X_transformed = pipeline.fit_transform(X)

print(X_transformed)

            

              
                Copy
              
            
          

Dieses Beispiel zeigt, wie der AddConstantTransformer in einer Pipeline verwendet wird. Zuerst werden die Daten mit StandardScaler skaliert, und dann wird die Konstante mit unserem benutzerdefinierten Transformator hinzugefügt.

Fortgeschrittene Entwicklung benutzerdefinierter Transformatoren

Lassen Sie uns nun einige fortgeschrittenere Szenarien und Techniken zur Erstellung benutzerdefinierter Transformatoren erkunden.

Umgang mit kategorialen Merkmalen

Kategoriale Merkmale sind ein häufiger Datentyp im maschinellen Lernen. Sie können benutzerdefinierte Transformatoren erstellen, um verschiedene Operationen an kategorialen Merkmalen durchzuführen, wie z. B. One-Hot-Encoding, Label-Encoding oder Feature-Hashing.

Hier ist ein Beispiel für einen benutzerdefinierten Transformator, der One-Hot-Encoding auf bestimmten Spalten durchführt:

            import pandas as pd
from sklearn.preprocessing import OneHotEncoder

class CategoricalEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None):
        self.categorical_features = categorical_features
        self.encoder = None

    def fit(self, X, y=None):
        if self.categorical_features is None:
            self.categorical_features = X.select_dtypes(include=['object']).columns

        self.encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
        self.encoder.fit(X[self.categorical_features])
        return self

    def transform(self, X):
        X_encoded = self.encoder.transform(X[self.categorical_features])
        X_encoded = pd.DataFrame(X_encoded, index=X.index, columns=self.encoder.get_feature_names_out(self.categorical_features))
        X = X.drop(columns=self.categorical_features)
        X = pd.concat([X, X_encoded], axis=1)
        return X

            

              
                Copy
              
            
          

In diesem Beispiel:

• Der Transformator identifiziert kategoriale Spalten automatisch (falls nicht angegeben).
• Er verwendet OneHotEncoder aus Scikit-learn, um die Kodierung durchzuführen.
• Er behandelt unbekannte Kategorien mit handle_unknown='ignore'.
• Die kodierten Merkmale werden wieder mit dem ursprünglichen DataFrame verkettet.

Umgang mit fehlenden Werten

Fehlende Werte sind ein weiteres häufiges Problem in Datensätzen für maschinelles Lernen. Sie können benutzerdefinierte Transformatoren erstellen, um fehlende Werte mit verschiedenen Strategien zu imputieren, wie z. B. der Imputation mit dem Mittelwert, dem Median oder dem Modus.

Hier ist ein Beispiel für einen benutzerdefinierten Transformator, der fehlende Werte mit dem Median imputiert:

            from sklearn.impute import SimpleImputer

class MissingValueImputer(BaseEstimator, TransformerMixin):
    def __init__(self, strategy='median', missing_values=np.nan):
        self.strategy = strategy
        self.missing_values = missing_values
        self.imputer = None

    def fit(self, X, y=None):
        self.imputer = SimpleImputer(strategy=self.strategy, missing_values=self.missing_values)
        self.imputer.fit(X)
        return self

    def transform(self, X):
        return self.imputer.transform(X)

            

              
                Copy
              
            
          

Dieser Transformator verwendet SimpleImputer aus Scikit-learn, um die Imputation durchzuführen. Er ermöglicht es Ihnen, die Imputationsstrategie und den Wert anzugeben, der zur Darstellung fehlender Werte verwendet wird.

Merkmalskalierung und Normalisierung

Merkmalskalierung und Normalisierung sind wichtige Vorverarbeitungsschritte für viele Algorithmen des maschinellen Lernens. Sie können benutzerdefinierte Transformatoren erstellen, um verschiedene Skalierungs- und Normalisierungstechniken zu implementieren.

Obwohl Scikit-learn Transformatoren wie StandardScaler und MinMaxScaler bereitstellt, benötigen Sie möglicherweise einen benutzerdefinierten Skalierer für spezifische Datenverteilungen. Wenn Sie beispielsweise Daten mit einer sehr schiefen Verteilung haben, könnte ein PowerTransformer (ebenfalls in Scikit-learn verfügbar) besser geeignet sein. Sie können ihn jedoch in einen benutzerdefinierten Transformator kapseln, um seine Parameter zu verwalten und ihn nahtlos in Ihre Pipeline zu integrieren.

            from sklearn.preprocessing import PowerTransformer

class SkewedDataTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, method='yeo-johnson'):
        self.method = method
        self.transformer = None

    def fit(self, X, y=None):
        self.transformer = PowerTransformer(method=self.method)
        self.transformer.fit(X)
        return self

    def transform(self, X):
        return self.transformer.transform(X)

            

              
                Copy
              
            
          

Kombinieren mehrerer Transformationen

Manchmal müssen Sie möglicherweise mehrere Transformationen auf dieselben Daten anwenden. Sie können einen benutzerdefinierten Transformator erstellen, der mehrere Transformationen in einem einzigen Schritt kombiniert. Dies kann helfen, Ihre Pipeline zu vereinfachen und lesbarer zu machen.

Hier ist ein Beispiel für einen benutzerdefinierten Transformator, der One-Hot-Encoding und die Imputation fehlender Werte kombiniert:

            class CombinedTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None, missing_value_strategy='median'):
        self.categorical_features = categorical_features
        self.missing_value_strategy = missing_value_strategy
        self.categorical_encoder = None
        self.missing_value_imputer = None

    def fit(self, X, y=None):
        self.categorical_encoder = CategoricalEncoder(categorical_features=self.categorical_features)
        self.missing_value_imputer = MissingValueImputer(strategy=self.missing_value_strategy)
        self.categorical_encoder.fit(X)
        self.missing_value_imputer.fit(X)
        return self

    def transform(self, X):
        X = self.categorical_encoder.transform(X)
        X = self.missing_value_imputer.transform(X)
        return X

            

              
                Copy
              
            
          

Dieser Transformator verwendet den CategoricalEncoder und den MissingValueImputer aus den vorherigen Beispielen, um sowohl das One-Hot-Encoding als auch die Imputation fehlender Werte in einem einzigen Schritt durchzuführen.

Best Practices für die Entwicklung benutzerdefinierter Transformatoren

Hier sind einige Best Practices, die Sie bei der Entwicklung benutzerdefinierter Transformatoren befolgen sollten:

• Halten Sie es einfach: Jeder Transformator sollte eine einzelne, klar definierte Aufgabe erfüllen.
• Machen Sie es wiederverwendbar: Gestalten Sie Ihre Transformatoren so generisch wie möglich, damit sie in verschiedenen Pipelines wiederverwendet werden können.
• Behandeln Sie Randfälle: Überlegen Sie, wie Ihr Transformator mit Randfällen wie fehlenden Werten, Ausreißern und unerwarteten Datentypen umgehen wird.
• Schreiben Sie Unit-Tests: Schreiben Sie Unit-Tests, um sicherzustellen, dass Ihr Transformator korrekt funktioniert.
• Dokumentieren Sie Ihren Code: Dokumentieren Sie Ihren Code klar, damit andere verstehen können, wie Ihr Transformator zu verwenden ist.

Beispiele aus der Praxis

Lassen Sie uns einige weitere Beispiele aus der Praxis für benutzerdefinierte Transformatoren untersuchen.

Feature Engineering für Datumsangaben

Bei der Arbeit mit Zeitreihendaten ist es oft nützlich, Merkmale aus Datumsangaben zu extrahieren, wie z. B. den Wochentag, den Monat des Jahres oder das Quartal. Sie können einen benutzerdefinierten Transformator erstellen, um diese Aufgabe zu erledigen.

            class DateFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, date_columns=None):
        self.date_columns = date_columns

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        for col in self.date_columns:
            X[col + '_dayofweek'] = X[col].dt.dayofweek
            X[col + '_month'] = X[col].dt.month
            X[col + '_quarter'] = X[col].dt.quarter
        return X

            

              
                Copy
              
            
          

Dieser Transformator extrahiert den Wochentag, den Monat und das Quartal aus den angegebenen Datumsspalten.

Feature Engineering für Texte

Bei der Arbeit mit Textdaten ist es oft nützlich, Feature Engineering mit Techniken wie TF-IDF oder Word Embeddings durchzuführen. Sie können benutzerdefinierte Transformatoren erstellen, um diese Aufgaben zu erledigen. Betrachten Sie zum Beispiel Kundenrezensionen in mehreren Sprachen. Möglicherweise benötigen Sie einen benutzerdefinierten Transformator, der die Rezensionen ins Englische übersetzt, bevor die TF-IDF-Vektorisierung angewendet wird.

Hinweis: Übersetzungsdienste erfordern oft API-Schlüssel und können Kosten verursachen. Dieses Beispiel konzentriert sich auf die Struktur des benutzerdefinierten Transformators.

            # Hinweis: Dieses Beispiel erfordert einen Übersetzungsdienst (z.B. Google Translate API) und einen API-Schlüssel
# from googletrans import Translator # Beispiel-Bibliothek (Installation mit pip install googletrans==4.0.0-rc1)

class TextFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, text_column, language='en'):
        self.text_column = text_column
        self.language = language
        # self.translator = Translator() # Übersetzer instanziieren (erfordert Einrichtung)

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        # Beispiel: Ins Englische übersetzen (durch tatsächliche Übersetzungslogik ersetzen)
        # X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: self.translator.translate(text, dest=self.language).text)
        # Dummy-Übersetzung zu Demonstrationszwecken
        X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: "Translated: " + text)

        # Wenden Sie hier TF-IDF oder andere Textvektorisierungstechniken an
        return X

            

              
                Copy
              
            
          

Geospatiales Feature Engineering

Bei der Arbeit mit geospatiale Daten können Sie benutzerdefinierte Transformatoren erstellen, um Merkmale wie die Entfernung zur nächsten Stadt, die Bevölkerungsdichte oder die Art der Landnutzung zu extrahieren. Betrachten Sie zum Beispiel die Analyse von Immobilienpreisen weltweit. Sie könnten einen benutzerdefinierten Transformator erstellen, der das durchschnittliche Einkommensniveau für einen bestimmten Standort unter Verwendung externer APIs basierend auf Breiten- und Längengrad abruft.

Integration mit bestehenden Bibliotheken

Benutzerdefinierte Transformatoren können verwendet werden, um Funktionalitäten aus anderen Python-Bibliotheken in eine Scikit-learn-Pipeline zu integrieren. Dies ermöglicht es Ihnen, die Leistungsfähigkeit anderer Bibliotheken zu nutzen und gleichzeitig von der Struktur und Organisation einer Pipeline zu profitieren.

Zum Beispiel könnten Sie einen benutzerdefinierten Transformator verwenden, um eine Bibliothek für Anomalieerkennung, Zeitreihenprognose oder Bildverarbeitung in Ihre Machine-Learning-Pipeline zu integrieren.

Fazit

Benutzerdefinierte Transformatoren sind ein leistungsstarkes Werkzeug zur Erstellung robuster und wartbarer Machine-Learning-Pipelines in Scikit-learn. Indem Sie Ihre benutzerdefinierte Datenverarbeitungslogik in wiederverwendbaren Komponenten kapseln, können Sie Pipelines erstellen, die leichter zu verstehen, zu aktualisieren und bereitzustellen sind. Denken Sie daran, Best Practices zu befolgen, Unit-Tests zu schreiben und Ihren Code zu dokumentieren, um sicherzustellen, dass Ihre benutzerdefinierten Transformatoren zuverlässig und wartbar sind. Während Sie Ihre Fähigkeiten im maschinellen Lernen entwickeln, wird die Beherrschung der Entwicklung benutzerdefinierter Transformatoren von unschätzbarem Wert sein, um komplexe und vielfältige reale Probleme auf der ganzen Welt anzugehen. Von der Handhabung von Währungsumrechnungen für den internationalen E-Commerce bis hin zur Verarbeitung von Sensordaten von IoT-Geräten weltweit – benutzerdefinierte Transformatoren ermöglichen es Ihnen, Ihre Pipelines auf die spezifischen Bedürfnisse Ihrer Daten und Anwendungen zuzuschneiden.